```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Java方法详解 - 编程基础</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', 'Noto Serif SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background-color: #f8fafc;
            color: #1e293b;
            line-height: 1.6;
        }
        .hero {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
            color: white;
        }
        .code-block {
            background-color: #1e1e2d;
            color: #d4d4d4;
            border-radius: 0.5rem;
            padding: 1.5rem;
            font-family: 'Menlo', 'Monaco', 'Consolas', 'Courier New', monospace;
            position: relative;
        }
        .code-block::before {
            content: '';
            position: absolute;
            top: 0;
            left: 0;
            width: 4px;
            height: 100%;
            background: linear-gradient(to bottom, #4f46e5, #7c3aed);
            border-radius: 0.5rem 0 0 0.5rem;
        }
        .feature-card {
            transition: all 0.3s ease;
            border-radius: 0.5rem;
            overflow: hidden;
        }
        .feature-card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.1);
        }
        .feature-icon {
            width: 60px;
            height: 60px;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            margin: 0 auto 1rem;
            font-size: 1.5rem;
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
            color: white;
        }
        .header-anchor {
            color: #4f46e5;
            margin-right: 0.5rem;
            opacity: 0;
            transition: opacity 0.2s ease;
        }
        h2:hover .header-anchor, h3:hover .header-anchor {
            opacity: 1;
        }
        .diagram-container {
            background-color: white;
            border-radius: 0.5rem;
            padding: 1.5rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
        }
        .homework-item {
            border-left: 4px solid #4f46e5;
            padding-left: 1rem;
            margin-bottom: 1rem;
            transition: all 0.3s ease;
        }
        .homework-item:hover {
            background-color: #f1f5f9;
            transform: translateX(5px);
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-7xl mx-auto text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6">Java 方法详解</h1>
            <p class="text-xl md:text-2xl max-w-3xl mx-auto mb-8 opacity-90">
                掌握Java方法的精髓 - 从基础概念到高级应用
            </p>
            <div class="flex justify-center space-x-4">
                <a href="#concept" class="px-6 py-3 bg-white text-indigo-600 font-medium rounded-lg hover:bg-gray-100 transition duration-300">
                    <i class="fas fa-book-open mr-2"></i>开始学习
                </a>
                <a href="#homework" class="px-6 py-3 border border-white text-white font-medium rounded-lg hover:bg-white hover:bg-opacity-10 transition duration-300">
                    <i class="fas fa-tasks mr-2"></i>课后练习
                </a>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- Concept Section -->
        <section id="concept" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-lightbulb text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#concept" class="header-anchor"><i class="fas fa-link"></i></a>
                    方法的概念
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-8 feature-card">
                <div class="p-6">
                    <p class="text-lg text-gray-700 mb-6">
                        方法（Method）是编程中用于执行特定任务的一组语句的集合。在Java中，方法可以看作是一个子程序或子函数，用于执行特定的操作或计算，并且可以被其他部分调用和重复使用。
                    </p>
                    
                    <div class="grid md:grid-cols-2 gap-8 mb-8">
                        <div>
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1709022486010-36df64b7-5b04-40b4-aea5-6c1fb5adb35e.png" 
                                 alt="方法概念示意图" 
                                 class="w-full h-auto rounded-lg shadow-md">
                        </div>
                        <div>
                            <div class="mb-6">
                                <h3 class="text-xl font-semibold text-gray-800 mb-4">方法的特点：</h3>
                                <ul class="space-y-3">
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-box text-xs"></i>
                                        </span>
                                        <span><strong>封装性：</strong>方法将一系列操作封装在一起，提供了一种将代码组织成逻辑单元的方式，使得代码更加模块化和易于理解。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-redo text-xs"></i>
                                        </span>
                                        <span><strong>复用性：</strong>通过方法，可以在程序中多次调用执行相同的操作，避免了重复编写相同的代码，提高了代码的复用性和可维护性。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-expand text-xs"></i>
                                        </span>
                                        <span><strong>可扩展性：</strong>可以通过定义新的方法来扩展程序的功能，使得程序更加灵活和可扩展。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-exchange-alt text-xs"></i>
                                        </span>
                                        <span><strong>参数传递：</strong>方法可以接受参数作为输入，这些参数可以是任意类型的数据，用于在方法内部执行操作或计算。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-arrow-right text-xs"></i>
                                        </span>
                                        <span><strong>返回值：</strong>方法可以返回一个值，这个值可以是任意类型的数据，用于将方法内部计算得到的结果返回给调用者。</span>
                                    </li>
                                </ul>
                            </div>
                        </div>
                    </div>
                    
                    <p class="text-lg text-gray-700">
                        在Java中，方法由方法名、返回类型、参数列表和方法体组成。方法名用于唯一标识方法，返回类型指定了方法返回的数据类型，参数列表定义了方法接受的参数类型和顺序，方法体包含了方法要执行的具体操作。
                    </p>
                </div>
            </div>
        </section>

        <!-- Definition Section -->
        <section id="definition" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-code text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#definition" class="header-anchor"><i class="fas fa-link"></i></a>
                    方法的定义
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden feature-card">
                <div class="p-6">
                    <p class="text-lg text-gray-700 mb-6">
                        在Java中，方法是类的成员之一，用于封装特定的功能或行为，并且可以被其他部分调用和重复使用。方法的定义和结构包括以下几个关键要素：
                    </p>
                    
                    <div class="grid md:grid-cols-2 gap-8 mb-8">
                        <div>
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1709022546738-2fbeca0f-6680-404b-a7db-8a1830ff1561.png" 
                                 alt="方法定义示意图" 
                                 class="w-full h-auto rounded-lg shadow-md">
                        </div>
                        <div>
                            <div class="mb-6">
                                <h3 class="text-xl font-semibold text-gray-800 mb-4">方法定义要素：</h3>
                                <ul class="space-y-3">
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-terminal text-xs"></i>
                                        </span>
                                        <span><strong>方法声明：</strong>包括方法的修饰符、返回类型、方法名和参数列表。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-key text-xs"></i>
                                        </span>
                                        <span><strong>修饰符：</strong>指定方法的访问权限和其他特性，如public、protected、private等。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-undo text-xs"></i>
                                        </span>
                                        <span><strong>返回类型：</strong>指定方法执行后返回的数据类型，可以是基本类型、引用类型或void。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-signature text-xs"></i>
                                        </span>
                                        <span><strong>方法名：</strong>用于唯一标识方法，采用驼峰命名法，具有描述性。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-list text-xs"></i>
                                        </span>
                                        <span><strong>参数列表：</strong>包括方法接受的参数类型和参数名，多个参数用逗号分隔。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-brackets-curly text-xs"></i>
                                        </span>
                                        <span><strong>方法体：</strong>包含方法要执行的具体操作，是方法的实际实现部分。</span>
                                    </li>
                                </ul>
                            </div>
                        </div>
                    </div>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mb-4">方法定义示例：</h3>
                    <div class="code-block mb-6">
                        <pre class="overflow-x-auto"><code class="language-java">public class MyClass {
    // 方法声明
    public int add(int num1, int num2) {
        // 方法体
        int sum = num1 + num2;
        return sum;
    }
}</code></pre>
                    </div>
                    
                    <p class="text-lg text-gray-700">
                        在这个例子中，方法名是add，返回类型是int，参数列表包括两个整型参数num1和num2。方法体中执行了这两个参数的加法操作，并将结果返回给调用者。
                    </p>
                </div>
            </div>
        </section>

        <!-- Call Section -->
        <section id="call" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-phone-alt text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#call" class="header-anchor"><i class="fas fa-link"></i></a>
                    方法的调用
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden feature-card">
                <div class="p-6">
                    <p class="text-lg text-gray-700 mb-6">
                        方法的调用是指在程序中使用方法名和参数列表来执行方法体内的代码。在Java中，方法的调用可以发生在同一个类中，也可以发生在不同的类中。
                    </p>
                    
                    <div class="grid md:grid-cols-2 gap-8 mb-8">
                        <div>
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1709023515219-23711161-9e88-497a-82a8-fdf18a8cbc1e.png" 
                                 alt="方法调用示意图" 
                                 class="w-full h-auto rounded-lg shadow-md">
                        </div>
                        <div>
                            <div class="mb-6">
                                <h3 class="text-xl font-semibold text-gray-800 mb-4">方法调用的关键要点：</h3>
                                <ul class="space-y-3">
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-signature text-xs"></i>
                                        </span>
                                        <span><strong>方法名：</strong>调用方法时需要指定方法的名称，以告诉编译器需要执行哪个方法。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-list text-xs"></i>
                                        </span>
                                        <span><strong>参数列表：</strong>调用方法时需要提供方法所需的参数列表，参数列表中包含了调用方法时传递给方法的数据。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-arrow-right text-xs"></i>
                                        </span>
                                        <span><strong>方法返回值：</strong>如果方法有返回值，调用方法后可以使用方法的返回值进行后续的操作。</span>
                                    </li>
                                </ul>
                            </div>
                        </div>
                    </div>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mb-4">方法调用的两种方式：</h3>
                    <div class="grid md:grid-cols-2 gap-6 mb-6">
                        <div>
                            <div class="bg-indigo-50 p-4 rounded-lg">
                                <h4 class="font-semibold text-indigo-700 mb-2 flex items-center">
                                    <i class="fas fa-project-diagram mr-2"></i> 同一个类中调用
                                </h4>
                                <p class="text-gray-700">
                                    在同一个类中可以直接调用方法，通过方法名和参数列表来调用。
                                </p>
                            </div>
                        </div>
                        <div>
                            <div class="bg-indigo-50 p-4 rounded-lg">
                                <h4 class="font-semibold text-indigo-700 mb-2 flex items-center">
                                    <i class="fas fa-sitemap mr-2"></i> 不同类中调用
                                </h4>
                                <p class="text-gray-700">
                                    在不同的类中调用方法时，需要先创建方法所在类的对象，然后通过对象名调用方法。
                                </p>
                            </div>
                        </div>
                    </div>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mb-4">方法调用示例：</h3>
                    <div class="code-block mb-6">
                        <pre class="overflow-x-auto"><code class="language-java">public class Example {
    // 定义一个方法，接受两个整数参数，并返回它们的和
    public int add(int num1, int num2) {
        int sum = num1 + num2;
        return sum;
    }

    public static void main(String[] args) {
        Example example = new Example(); // 创建Example类的实例
        int result = example.add(10, 20); // 调用add方法，传递两个整数参数
        System.out.println("Sum: " + result); // 打印结果
    }
}</code></pre>
                    </div>
                    
                    <p class="text-lg text-gray-700">
                        在这个例子中，main方法中创建了Example类的实例example，然后通过example对象调用add方法并传递了两个整数参数10和20。调用add方法后，方法返回了两个整数的和，结果被存储在result变量中，并最终被打印出来。方法的调用是程序执行的重要步骤之一，通过调用方法可以执行方法体内的代码并实现特定的功能。
                    </p>
                </div>
            </div>
        </section>

        <!-- Parameters Section -->
        <section id="parameters" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-sliders-h text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#parameters" class="header-anchor"><i class="fas fa-link"></i></a>
                    方法参数
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden feature-card">
                <div class="p-6">
                    <p class="text-lg text-gray-700 mb-6">
                        方法参数是指在方法声明中定义的变量，用于接收调用该方法时传递进来的数据。在Java中，方法可以接受零个或多个参数，这些参数被包含在方法的参数列表中，并且在方法体内可以被使用。
                    </p>
                    
                    <div class="grid md:grid-cols-2 gap-8 mb-8">
                        <div>
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1709023163706-af196864-d539-464f-886e-22711f7d563b.png" 
                                 alt="方法参数示意图" 
                                 class="w-full h-auto rounded-lg shadow-md">
                        </div>
                        <div>
                            <div class="mb-6">
                                <h3 class="text-xl font-semibold text-gray-800 mb-4">方法参数的关键要点：</h3>
                                <ul class="space-y-3">
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-tag text-xs"></i>
                                        </span>
                                        <span><strong>参数类型：</strong>每个参数都有一个数据类型，指定了参数可以接受的数据类型。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-signature text-xs"></i>
                                        </span>
                                        <span><strong>参数名：</strong>用于在方法体内引用传递进来的数据，应该具有描述性。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-sort-numeric-up-alt text-xs"></i>
                                        </span>
                                        <span><strong>参数顺序：</strong>调用方法时必须按照参数顺序传递相应的数据。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-list-ol text-xs"></i>
                                        </span>
                                        <span><strong>参数数量：</strong>方法可以定义任意数量的参数，包括零个或多个。</span>
                                    </li>
                                </ul>
                            </div>
                        </div>
                    </div>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mb-4">方法参数示例：</h3>
                    <div class="code-block mb-6">
                        <pre class="overflow-x-auto"><code class="language-java">public class Example {
    // 定义一个方法，接受两个整数参数，并返回它们的和
    public int add(int num1, int num2) {
        int sum = num1 + num2;
        return sum;
    }

    public static void main(String[] args) {
        Example example = new Example();
        int result = example.add(10, 20); // 调用add方法，传递两个整数参数
        System.out.println("Sum: " + result); // 打印结果
    }
}</code></pre>
                    </div>
                    
                    <p class="text-lg text-gray-700">
                        在这个例子中，add方法接受两个整数参数num1和num2，并返回它们的和。在main方法中，我们创建了Example类的实例，并调用add方法传递了两个整数参数10和20，然后将返回的结果打印出来。方法的参数是方法与外部环境之间进行数据交换的重要方式，通过参数的传递，可以使方法具有更强大的功能和灵活性。
                    </p>
                </div>
            </div>
        </section>

        <!-- Return Section -->
        <section id="return" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-reply text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#return" class="header-anchor"><i class="fas fa-link"></i></a>
                    方法的返回值
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden feature-card">
                <div class="p-6">
                    <p class="text-lg text-gray-700 mb-6">
                        方法的返回值指的是方法执行完毕后返回的结果。在Java中，方法可以有返回值，也可以没有返回值。
                    </p>
                    
                    <div class="grid md:grid-cols-2 gap-8 mb-8">
                        <div>
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1709023258613-8018db95-c5dc-4e9d-a285-b59b58f7dad9.png" 
                                 alt="方法返回值示意图" 
                                 class="w-full h-auto rounded-lg shadow-md">
                        </div>
                        <div>
                            <div class="mb-6">
                                <h3 class="text-xl font-semibold text-gray-800 mb-4">有返回值的方法：</h3>
                                <ul class="space-y-3">
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-arrow-down text-xs"></i>
                                        </span>
                                        <span><strong>定义方法返回值类型：</strong>在方法声明时，需要指定方法的返回值类型。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-reply text-xs"></i>
                                        </span>
                                        <span><strong>使用return语句返回值：</strong>在方法体内，使用return语句将结果返回给调用方。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-check-circle text-xs"></i>
                                        </span>
                                        <span><strong>返回值类型一致：</strong>方法的返回值类型必须与return语句返回的值类型一致。</span>
                                    </li>
                                </ul>
                            </div>
                            
                            <div class="mt-8">
                                <h3 class="text-xl font-semibold text-gray-800 mb-4">无返回值的方法：</h3>
                                <p class="text-gray-700">
                                    有些方法不需要返回值，这种方法被称为void方法。它们通常用于执行某些操作而不需要返回结果。
                                </p>
                            </div>
                        </div>
                    </div>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mb-4">返回值示例：</h3>
                    <div class="grid md:grid-cols-2 gap-6 mb-6">
                        <div>
                            <div class="code-block">
                                <pre class="overflow-x-auto"><code class="language-java">// 有返回值的方法
public int add(int num1, int num2) {
    int sum = num1 + num2;
    return sum; // 返回两个整数的和
}</code></pre>
                            </div>
                        </div>
                        <div>
                            <div class="code-block">
                                <pre class="overflow-x-auto"><code class="language-java">// 无返回值的方法
public void printMessage(String message) {
    System.out.println(message);
}</code></pre>
                            </div>
                        </div>
                    </div>
                    
                    <p class="text-lg text-gray-700">
                        在上面的示例中，add方法返回两个整数的和，即计算得到的sum值。而printMessage方法不返回任何值，它只是打印传入的消息到控制台。
                    </p>
                </div>
            </div>
        </section>

        <!-- Overloading Section -->
        <section id="overloading" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-layer-group text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#overloading" class="header-anchor"><i class="fas fa-link"></i></a>
                    方法的重载
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden feature-card">
                <div class="p-6">
                    <p class="text-lg text-gray-700 mb-6">
                        方法重载(Overloading)是指在同一个类中，可以定义多个同名方法，但这些方法的参数列表必须不同（参数类型、参数数量或参数顺序不同）。方法重载是Java多态性的一种表现。
                    </p>
                    
                    <div class="grid md:grid-cols-2 gap-8 mb-8">
                        <div>
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1709023350738-6a384176-63f4-42d6-a0b1-0cec3cb7dd59.png" 
                                 alt="方法重载示意图" 
                                 class="w-full h-auto rounded-lg shadow-md">
                        </div>
                        <div>
                            <div class="mb-6">
                                <h3 class="text-xl font-semibold text-gray-800 mb-4">方法重载的特点：</h3>
                                <ul class="space-y-3">
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-signature text-xs"></i>
                                        </span>
                                        <span><strong>方法名相同：</strong>重载的方法必须使用相同的方法名。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-list text-xs"></i>
                                        </span>
                                        <span><strong>参数列表不同：</strong>参数类型、数量或顺序必须不同。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-exchange-alt text-xs"></i>
                                        </span>
                                        <span><strong>与返回值无关：</strong>方法重载与返回值类型无关。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-key text-xs"></i>
                                        </span>
                                        <span><strong>访问修饰符可以不同：</strong>重载方法可以有不同的访问修饰符。</span>
                                    </li>
                                </ul>
                            </div>
                        </div>
                    </div>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mb-4">方法重载示例：</h3>
                    <div class="code-block mb-6">
                        <pre class="overflow-x-auto"><code class="language-java">public class Calculator {
    // 重载方法1：两个整数相加
    public int add(int num1, int num2) {
        return num1 + num2;
    }
    
    // 重载方法2：三个整数相加
    public int add(int num1, int num2, int num3) {
        return num1 + num2 + num3;
    }
    
    // 重载方法3：两个双精度数相加
    public double add(double num1, double num2) {
        return num1 + num2;
    }
    
    // 重载方法4：一个整数和一个双精度数相加
    public double add(int num1, double num2) {
        return num1 + num2;
    }
    
    // 重载方法5：一个双精度数和一个整数相加
    public double add(double num1, int num2) {
        return num1 + num2;
    }
}</code></pre>
                    </div>
                    
                    <p class="text-lg text-gray-700">
                        在这个例子中，我们定义了5个名为add的重载方法，每个方法的参数列表都不相同。编译器会根据调用时传递的参数类型和数量来决定调用哪个具体的重载方法。
                    </p>
                </div>
            </div>
        </section>

        <!-- Purpose Section -->
        <section id="purpose" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-bullseye text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#purpose" class="header-anchor"><i class="fas fa-link"></i></a>
                    方法的作用
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden feature-card">
                <div class="p-6">
                    <p class="text-lg text-gray-700 mb-6">
                        方法是编程中的重要工具，能够有效地组织和管理代码，提高代码的复用性、可读性和可维护性，是面向对象编程的重要组成部分。
                    </p>
                    
                    <div class="grid md:grid-cols-2 gap-6 mb-8">
                        <div class="bg-indigo-50 p-6 rounded-lg">
                            <div class="feature-icon">
                                <i class="fas fa-redo"></i>
                            </div>
                            <h3 class="text-xl font-semibold text-gray-800 mb-3 text-center">代码重用和模块化</h3>
                            <p class="text-gray-700">
                                方法可以将一组代码封装成一个独立的功能单元，在程序中可以多次调用，实现代码的重用，提高了代码的可维护性和可读性。通过将程序拆分成多个方法，可以实现模块化的编程，使程序结构更加清晰。
                            </p>
                        </div>
                        
                        <div class="bg-indigo-50 p-6 rounded-lg">
                            <div class="feature-icon">
                                <i class="fas fa-book-reader"></i>
                            </div>
                            <h3 class="text-xl font-semibold text-gray-800 mb-3 text-center">提高代码的可读性和可维护性</h3>
                            <p class="text-gray-700">
                                良好命名和设计的方法能够使代码更易于理解和维护。将代码逻辑封装在方法中，可以使代码更加简洁明了，降低了程序的复杂度，有助于他人理解和修改代码。
                            </p>
                        </div>
                        
                        <div class="bg-indigo-50 p-6 rounded-lg">
                            <div class="feature-icon">
                                <i class="fas fa-lock"></i>
                            </div>
                            <h3 class="text-xl font-semibold text-gray-800 mb-3 text-center">隐藏实现细节</h3>
                            <p class="text-gray-700">
                                方法可以隐藏具体的实现细节，只暴露方法的接口。通过封装和隐藏实现细节，可以降低代码的耦合度，提高代码的安全性和可维护性。
                            </p>
                        </div>
                        
                        <div class="bg-indigo-50 p-6 rounded-lg">
                            <div class="feature-icon">
                                <i class="fas fa-expand"></i>
                            </div>
                            <h3 class="text-xl font-semibold text-gray-800 mb-3 text-center">提高程序的可扩展性和灵活性</h3>
                            <p class="text-gray-700">
                                通过定义方法，可以将程序的功能模块化，便于对程序进行扩展和修改。如果需要修改某个功能，只需要修改对应的方法，而不需要修改整个程序。
                            </p>
                        </div>
                        
                        <div class="bg-indigo-50 p-6 rounded-lg md:col-span-2">
                            <div class="feature-icon">
                                <i class="fas fa-shapes"></i>
                            </div>
                            <h3 class="text-xl font-semibold text-gray-800 mb-3 text-center">实现抽象和多态</h3>
                            <p class="text-gray-700">
                                方法的定义可以实现抽象的概念，例如定义一个抽象方法，让子类去实现具体的逻辑，实现了面向对象编程中的多态特性。
                            </p>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Encapsulation Section -->
        <section id="encapsulation" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-box text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#encapsulation" class="header-anchor"><i class="fas fa-link"></i></a>
                    方法的封装
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden feature-card">
                <div class="p-6">
                    <p class="text-lg text-gray-700 mb-6">
                        方法的封装指的是将方法的实现细节隐藏起来，只对外部暴露必要的接口和功能。通过封装，可以将数据和方法组织成一个独立的单元，从而提高代码的可维护性、安全性和灵活性。
                    </p>
                    
                    <div class="grid md:grid-cols-2 gap-8 mb-8">
                        <div class="diagram-container">
                            <div class="mermaid">
                                classDiagram
                                    class BankAccount {
                                        -balance: double
                                        +deposit(amount: double): void
                                        +withdraw(amount: double): boolean
                                        +getBalance(): double
                                    }
                            </div>
                        </div>
                        <div>
                            <div class="mb-6">
                                <h3 class="text-xl font-semibold text-gray-800 mb-4">方法封装的主要作用：</h3>
                                <ul class="space-y-3">
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-eye-slash text-xs"></i>
                                        </span>
                                        <span><strong>隐藏实现细节：</strong>封装可以隐藏方法的具体实现细节，只暴露对外的接口。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-shield-alt text-xs"></i>
                                        </span>
                                        <span><strong>提高安全性：</strong>通过封装，可以将方法内部的数据和行为进行保护，只允许通过指定的接口进行访问。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-filter text-xs"></i>
                                        </span>
                                        <span><strong>简化接口：</strong>封装使得外部调用者只需要关注方法的接口，而不必关心其具体实现细节。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-tools text-xs"></i>
                                        </span>
                                        <span><strong>提高可维护性：</strong>封装可以将代码组织成模块化的结构，提高了代码的可维护性。</span>
                                    </li>
                                </ul>
                            </div>
                        </div>
                    </div>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mb-4">方法封装示例：</h3>
                    <div class="code-block mb-6">
                        <pre class="overflow-x-auto"><code class="language-java">public class BankAccount {
    private double balance;  // 私有字段，外部不能直接访问
    
    // 存款方法
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功，当前余额: " + balance);
        } else {
            System.out.println("存款金额必须大于0");
        }
    }
    
    // 取款方法
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("取款成功，当前余额: " + balance);
            return true;
        } else {
            System.out.println("取款失败，余额不足或金额无效");
            return false;
        }
    }
    
    // 查询余额方法
    public double getBalance() {
        return balance;
    }
}</code></pre>
                    </div>
                    
                    <p class="text-lg text-gray-700">
                        在这个例子中，BankAccount类封装了一个银行账户的实现。balance字段被声明为private，外部不能直接访问，只能通过deposit、withdraw和getBalance这些公共方法来操作账户。这样既保护了数据的安全，又简化了外部调用者的使用。
                    </p>
                </div>
            </div>
        </section>

        <!-- Recursion Section -->
        <section id="recursion" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-infinity text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#recursion" class="header-anchor"><i class="fas fa-link"></i></a>
                    方法的递归
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden feature-card">
                <div class="p-6">
                    <p class="text-lg text-gray-700 mb-6">
                        方法的递归是指在方法内部调用自身的过程。递归是一种强有力的编程技巧，它允许方法在解决问题时重复调用自身，从而简化复杂的问题并提高代码的可读性和可维护性。
                    </p>
                    
                    <div class="grid md:grid-cols-2 gap-8 mb-8">
                        <div>
                            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1709023826606-8c6b7741-2b29-4795-b60c-bdc86fa29330.png" 
                                 alt="递归方法示意图" 
                                 class="w-full h-auto rounded-lg shadow-md">
                        </div>
                        <div>
                            <div class="mb-6">
                                <h3 class="text-xl font-semibold text-gray-800 mb-4">递归方法的特点：</h3>
                                <ul class="space-y-3">
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-circle-notch text-xs"></i>
                                        </span>
                                        <span><strong>自调用：</strong>递归方法在执行过程中会反复调用自身，直到满足某个终止条件为止。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-stop-circle text-xs"></i>
                                        </span>
                                        <span><strong>终止条件：</strong>必须包含一个或多个终止条件，否则会导致无限递归。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-project-diagram text-xs"></i>
                                        </span>
                                        <span><strong>问题分解：</strong>通常用于解决可以分解为相似子问题的问题。</span>
                                    </li>
                                    <li class="flex items-start">
                                        <span class="flex-shrink-0 w-6 h-6 bg-indigo-100 text-indigo-600 rounded-full flex items-center justify-center mr-3 mt-1">
                                            <i class="fas fa-layer-group text-xs"></i>
                                        </span>
                                        <span><strong>栈空间：</strong>递归调用使用栈空间，深度过大会导致栈溢出。</span>
                                    </li>
                                </ul>
                            </div>
                        </div>
                    </div>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mb-4">递归方法示例：计算阶乘</h3>
                    <div class="grid md:grid-cols-2 gap-6 mb-6">
                        <div>
                            <div class="code-block">
                                <pre class="overflow-x-auto"><code class="language-java">// 递归方法计算阶乘
public static int factorial(int n) {
    // 终止条件
    if (n == 0 || n == 1) {
        return 1;
    }
    // 递归调用
    return n * factorial(n - 1);
}

public static void main(String[] args) {
    System.out.println("5的阶乘是: " + factorial(5));
}</code></pre>
                            </div>
                        </div>
                        <div>
                            <div class="diagram-container">
                                <div class="mermaid">
                                    graph TD
                                        A[factorial(5)] --> B[5 * factorial(4)]
                                        B --> C[5 * 4 * factorial(3)]
                                        C --> D[5 * 4 * 3 * factorial(2)]
                                        D --> E[5 * 4 * 3 * 2 * factorial(1)]
                                        E --> F[5 * 4 * 3 * 2 * 1]
                                        F --> G[返回120]
                                </div>
                            </div>
                        </div>
                    </div>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mb-4">递归方法示例：斐波那契数列</h3>
                    <div class="grid md:grid-cols-2 gap-6">
                        <div>
                            <div class="code-block">
                                <pre class="overflow-x-auto"><code class="language-java">// 递归方法计算斐波那契数列
public static int fibonacci(int n) {
    // 终止条件
    if (n == 0) return 0;
    if (n == 1) return 1;
    // 递归调用
    return fibonacci(n - 1) + fibonacci(n - 2);
}

public static void main(String[] args) {
    System.out.println("斐波那契数列第10项: " + fibonacci(10));
}</code></pre>
                            </div>
                        </div>
                        <div>
                            <div class="diagram-container">
                                <div class="mermaid">
                                    graph TD
                                        A[fib(5)] --> B[fib(4)]
                                        A --> C[fib(3)]
                                        B --> D[fib(3)]
                                        B --> E[fib(2)]
                                        C --> F[fib(2)]
                                        C --> G[fib(1)]
                                        D --> H[fib(2)]
                                        D --> I[fib(1)]
                                        E --> J[fib(1)]
                                        E --> K[fib(0)]
                                        F --> L[fib(1)]
                                        F --> M[fib(0)]
                                        H --> N[fib(1)]
                                        H --> O[fib(0)]
                                </div>
                            </div>
                        </div>
                    </div>
                    
                    <div class="bg-yellow-50 border-l-4 border-yellow-400 p-4 mt-6">
                        <div class="flex">
                            <div class="flex-shrink-0">
                                <i class="fas fa-exclamation-triangle text-yellow-400"></i>
                            </div>
                            <div class="ml-3">
                                <p class="text-sm text-yellow-700">
                                    <strong>注意：</strong>虽然递归方法能够简化问题的解决过程，但需要注意递归深度过大可能导致栈溢出的问题，因此在使用递归时需要谨慎考虑终止条件和递归调用的次数。对于需要深度递归的问题，可以考虑使用迭代方案替代。
                                </p>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Homework Section -->
        <section id="homework" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-12 rounded-full bg-indigo-100 flex items-center justify-center text-indigo-600 mr-4">
                    <i class="fas fa-tasks text-xl"></i>
                </div>
                <h2 class="text-3xl font-bold text-gray-800">
                    <a href="#homework" class="header-anchor"><i class="fas fa-link"></i></a>
                    当天作业
                </h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden feature-card">
                <div class="p-6">
                    <div class="space-y-4">
                        <div class="homework-item">
                            <h3 class="text-xl font-semibold text-gray-800 mb-2">1. 描述什么是方法重载</h3>
                            <p class="text-gray-700">
                                请简要描述方法重载的概念，并举例说明。
                            </p>
                        </div>
                        
                        <div class="homework-item">
                            <h3 class="text-xl font-semibold text-gray-800 mb-2">2. 打印一个直角三角形</h3>
                            <p class="text-gray-700">
                                编写一个方法，要求可以通过方法参数的形式来控制打印的图形以及高度。
                            </p>
                        </div>
                        
                        <div class="homework-item">
                            <h3 class="text-xl font-semibold text-gray-800 mb-2">3. 乘法表</h3>
                            <p class="text-gray-700">
                                键盘录入一个数据n(1<=n<=9)，输出对应的n*n乘法表。
                            </p>
                        </div>
                        
                        <div class="homework-item">
                            <h3 class="text-xl font-semibold text-gray-800 mb-2">4. 素数判断</h3>
                            <p class="text-gray-700">
                                素数也叫质数，是除了1和其本身，不能被其他正整数整除的正整数。例如：2,3,5,7,11,13,17,19,23.....
                            </p>
                            <ul class="list-disc list-inside mt-2 text-gray-700">
                                <li>写一个方法判断该数是否为素数（设计成一个方法 boolean）</li>
                                <li>输出某个范围内的所有素数，比如100-200之间。</li>
                            </ul>
                        </div>
                        
                        <div class="homework-item">
                            <h3 class="text-xl font-semibold text-gray-800 mb-2">5. 闰年判断</h3>
                            <p class="text-gray-700">
                                闰年，能被4整除而且不能被100整除，或者能被400整除就是闰年。
                            </p>
                            <ul class="list-disc list-inside mt-2 text-gray-700">
                                <li>判断某个年份是否为闰年(设计成一个方法 boolean)</li>
                                <li>输出一个范围内的哪些年份是闰年（从2000至2020年）</li>
                            </ul>
                        </div>
                    </div>
                </div>
            </div>
        </section>
    </div>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-8">
        <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="text-center">
                <h3 class="text-xl font-semibold mb-2">技术小馆</h3>
                <p class="text-gray-400">
                    <a href="http://www.yuque.com/jtostring" class="hover:text-white transition duration-300">http://www.yuque.com/jtostring</a>
                </p>
            </div>
        </div>
    </footer>

    <script>
        // 初始化Mermaid图表
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // 平滑滚动到锚点
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
            });
        });
    </script>
</body>
</html>
```